package com.sykj.seaflow.warm.core.convert2;

import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import com.sykj.seaflow.warm.core.listener.GlobalAssignmentListener;
import com.sykj.seaflow.warm.core.listener.GlobalCreateListener;
import com.sykj.seaflow.warm.module.def.bean.SeaFlowNode;
import com.warm.flow.core.entity.Node;
import com.warm.flow.core.entity.Skip;
import com.warm.flow.core.enums.NodeType;
import com.warm.flow.core.enums.SkipType;
import com.warm.flow.core.listener.Listener;
import com.warm.flow.orm.entity.FlowSkip;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

public class ParallelNodeConvert extends NodeConvertAbstract {

    @Override
    public List<Node> convert(SeaFlowNode parentNode,JSONObject jsonNode, String startNodeId, String endNodeId){
        List<Node> seaflowNodeList = new ArrayList<>();
        JSONObject childNode = jsonNode.getJSONObject("childNode");
        // 网关节点处理完， 最后一个节点要跳转的id
        String parellerEndNodeId = childNode == null ? endNodeId : childNode.getStr("nodeId");

        // 网关节点前加一个空节点， 使用当前网关节点（jsonNode）的id
        String emptyNodeId = jsonNode.getStr("nodeId");

        //  网关节点（入） id
        String startParallelNodeId = UUID.randomUUID().toString();

        // 创建入网关前，需要加一个空节点，不然会出现多条历史记录, 所以当前节点的id 就要给空姐点用，
        SeaFlowNode emptyNode = getEmptyNode(emptyNodeId, startParallelNodeId);

        seaflowNodeList.add(emptyNode);

        // 创建入网关， 直接进去. 不需要判断前面是否完成
        SeaFlowNode serialNode = new SeaFlowNode();
        serialNode.setNodeCode(startParallelNodeId);
        serialNode.setNodeType(NodeType.PARALLEL.getKey());
        serialNode.setDirection("1");  //网关（入）
        //加一个并行网关
        seaflowNodeList.add(serialNode);

        // 条件节点 ，
        JSONArray conditionNodes = jsonNode.getJSONArray("conditionNodes");
        //  网关（出） 的 id , 条件节点最后一个连接此节点
        String  parellerOutNodeId = UUID.randomUUID().toString();
        for(Object jsonObject : conditionNodes ){
            JSONObject  conditionNode =  (JSONObject) jsonObject;
            List<Node> convert = NodeConvertHandler.convert(serialNode, conditionNode, startNodeId, parellerOutNodeId);
            // 网关（入） 添加连线
            FlowSkip flowSkip = new FlowSkip();
            flowSkip.setSkipType(SkipType.PASS.getKey());
            flowSkip.setNextNodeCode(conditionNode.getStr("nodeId"));
            serialNode.getSkipList().add(flowSkip);
            seaflowNodeList.addAll(convert);
        }

        // 网关出
        SeaFlowNode endNode = getNode(jsonNode);
        endNode.setNodeCode(parellerOutNodeId);
        FlowSkip parallelOutSkip = new FlowSkip();
        parallelOutSkip.setSkipType(SkipType.PASS.getKey());
        parallelOutSkip.setNextNodeCode(parellerEndNodeId);
        endNode.setSkipList(Arrays.asList(parallelOutSkip));


//        //网关出 跳转到一个自动完成节点
//        String emptyNodeCode  = UUID.randomUUID().toString();
//        //并行网关（出） 连接空节点
//        FlowSkip parallelOutSkip = new FlowSkip();
//        parallelOutSkip.setSkipType(SkipType.PASS.getKey());
//        parallelOutSkip.setNextNodeCode(emptyNodeCode);
//        endNode.setSkipList(Arrays.asList(parallelOutSkip));
//        // 先来一个空节点  网关不能直连的问题
//
//        // 并行网关（出） 后面再加一个空节点
//        SeaFlowNode emptyNode = new SeaFlowNode();
//        emptyNode.setNodeName("自动通过");
//        emptyNode.setNodeCode(emptyNodeCode);
//        emptyNode.setNodeType(NodeType.BETWEEN.getKey());
//        // 设置空类别自动通过， 区分前端审批人为空的配置
//        String emptyApprove = "{\"type\":\"EMPTY\",\"value\":[]}";
//        emptyNode.setEmptyApprove(emptyApprove);
//        // 多个用逗号分割， 这里先写死
//        emptyNode.setListenerType(String.join(",", Listener.LISTENER_ASSIGNMENT, Listener.LISTENER_CREATE));
//        emptyNode.setListenerPath(String.join("@@", GlobalAssignmentListener.class.getName(),
//                GlobalCreateListener.class.getName()));
//
//        FlowSkip emptySkip = new FlowSkip();
//        emptySkip.setSkipType(SkipType.PASS.getKey());
//        emptySkip.setNextNodeCode(parellerEndNodeId);
//        emptyNode.getSkipList().add(emptySkip);

        //


        // empty 节点 -> 在和子节点相连
        List<Node> nodes = nextNode(endNode, childNode, startNodeId, endNodeId);

        seaflowNodeList.add(endNode);
//        seaflowNodeList.add(emptyNode);
        seaflowNodeList.addAll(nodes);
        return seaflowNodeList;
    }

    @Override
    public String getType() {
        return "parallel";
    }
}
